package com.demo.java.OD201_250.OD245;

import java.util.Scanner;
import java.util.Stack;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【最长合法表达式】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146027509
 */
public class OdMain {
    // 判断字符是否为运算符
    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }

    // 判断字符是否为有效的表达式开始字符（数字或+，-）
    private static boolean isValidExpBeginChar(char c) {
        return '0' <= c && c <= '9' || c == '+' || c == '-';
    }

    // 计算表达式的值
    private static int calcExpStr(String expStr) {
        expStr += "+0"; // 确保表达式结束时加上0以便最后处理
        Stack<Integer> stack = new Stack<>();
        StringBuilder numStr = new StringBuilder();
        int num_coef = 1;
        boolean beforeIsDiv = false;  // 记录是否前一个运算符为除法

        // 遍历表达式字符串
        for (int i = 0; i < expStr.length(); i++) {
            char c = expStr.charAt(i);

            if ('9' >= c && c >= '0') {
                numStr.append(c);  // 如果是数字，继续拼接
            } else {
                // 数字计算处理
                int num = num_coef * Integer.parseInt(numStr.toString());
                if (beforeIsDiv) {
                    stack.push(stack.pop() / num);  // 除法操作
                } else {
                    stack.push(num);  // 加法或减法
                }
                beforeIsDiv = false;
                numStr.setLength(0);  // 重置数字字符串

                // 根据操作符设置符号和处理
                if (c == '+') {
                    num_coef = 1;
                } else if (c == '-') {
                    num_coef = -1;
                } else if (c == '*') {
                    num_coef = stack.pop();
                } else if (c == '/') {
                    num_coef = 1;
                    beforeIsDiv = true;
                }
            }
        }

        // 汇总结果
        int sum = stack.stream().mapToInt(Integer::intValue).sum();
        return sum;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();

        // 使用正则表达式分割表达式
        String[] subs = s.split("[^0-9+\\-*/]");

        String express = "";
        int maxLen = 0;

        // 遍历所有分割出的子表达式
        for (String sub : subs) {
            int l = 0;

            // 寻找有效的子表达式
            while (l < sub.length() && !isValidExpBeginChar(sub.charAt(l))) {
                l++;
            }

            if (l == sub.length()) {
                continue;
            }

            sub += "++";  // 防止处理到最后字符时出错

            int r = l + 1;
            while (r < sub.length()) {
                if (isOperator(sub.charAt(r)) && isOperator(sub.charAt(r - 1))) {
                    if (r - 1 - l > maxLen) {
                        String[] ts = sub.substring(l, r - 1).replace("/0", " 0").split(" ");
                        for (String tmp : ts) {
                            if (tmp.length() > maxLen) {
                                maxLen = tmp.length();
                                express = tmp;
                            }
                        }
                    }
                    l = r;
                    while (l < sub.length() && !isValidExpBeginChar(sub.charAt(l))) {
                        l++;
                    }
                    r = l;
                }
                r++;
            }
        }

        // 如果找到最大有效子表达式，计算并输出结果
        if (maxLen > 0) {
            int result = calcExpStr(express);
            System.out.println(result);
        } else {
            System.out.println(0);  // 没有有效子表达式，输出0
        }
    }
}